
#ifndef Int64_h
#define Int64_h

#include <System/Object.h>
#include <System/IFormattable.h>
#include <System/IConvertible.h>
#include <System/Generic/IComparable.h>
#include <System/Generic/IEquatable.h>
#include <System/Globalization/NumberStyles.h>
#include <System/DateTime.h>

namespace Riccsson
{
	namespace System
	{
		// Summary:
		//     Represents a 32-bit signed integer.
		struct Int64
			: public Object
			//, public IComparable
			, public IFormattable
			, public IConvertible
			, public Generic::IComparable<long long>
			, public Generic::IEquatable<long long>
		{
			REGISTER_CLASS(Int64)

		private:
			long long _internalInt64;

			// Summary:
			//     Represents the largest possible value of an System.Int64. This field is constant.
			public: static const long long MaxValue = 2147483647;
			//
			// Summary:
			//     Represents the smallest possible value of System.Int64. This field is constant.
			public: static const long long MinValue = -2147483647 - 1;

			//------------------------------------------------------------------------------
			// Constructor.
			Int64()
				: _internalInt64(0)
			{
			}

			//------------------------------------------------------------------------------
			// Constructor.
			Int64(const long long& value)
				: _internalInt64(value)
			{
			}

			//------------------------------------------------------------------------------
			// Copy constructor.
			Int64(const Int64& value)
				: _internalInt64(value._internalInt64)
			{
			}

			// Summary:
			//     Compares this instance to a specified 32-bit signed integer and returns an
			//     indication of their relative values.
			//
			// Parameters:
			//   value:
			//     An integer to compare.
			//
			// Returns:
			//     A signed number indicating the relative values of this instance and value.Return
			//     Value Description Less than zero This instance is less than value. Zero This
			//     instance is equal to value. Greater than zero This instance is greater than
			//     value.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: int CompareTo(long long* value);
			//
			// Summary:
			//     Compares this instance to a specified object and returns an indication of
			//     their relative values.
			//
			// Parameters:
			//   value:
			//     An object to compare, or null.
			//
			// Returns:
			//     A signed number indicating the relative values of this instance and value.Return
			//     Value Description Less than zero This instance is less than value. Zero This
			//     instance is equal to value. Greater than zero This instance is greater than
			//     value.-or- value is null.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     value is not an System.Int64.
			public: int CompareTo(object* value);
			//
			// Summary:
			//     Returns a value indicating whether this instance is equal to a specified
			//     System.Int64 value.
			//
			// Parameters:
			//   obj:
			//     An System.Int64 value to compare to this instance.
			//
			// Returns:
			//     true if obj has the same value as this instance; otherwise, false.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: bool Equals(long long* obj);
			//
			// Summary:
			//     Returns a value indicating whether this instance is equal to a specified
			//     object.
			//
			// Parameters:
			//   obj:
			//     An object to compare with this instance.
			//
			// Returns:
			//     true if obj is an instance of System.Int64 and equals the value of this instance;
			//     otherwise, false.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: override bool Equals(object* obj);
			//
			// Summary:
			//     Returns the hash code for this instance.
			//
			// Returns:
			//     A 32-bit signed integer hash code.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: override int GetHashCode();
			//
			// Summary:
			//     Returns the System.TypeCode for value type System.Int64.
			//
			// Returns:
			//     The enumerated constant, System.TypeCode.Int64.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: TypeCode GetTypeCode();
			//
			// Summary:
			//     Converts the string representation of a number to its 32-bit signed integer
			//     equivalent.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the number contained in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not in the correct format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Int64.MinValue or greater than System.Int64.MaxValue.
			public: static int Parse(string* s);
			//
			// Summary:
			//     Converts the string representation of a number in a specified culture-specific
			//     format to its 32-bit signed integer equivalent.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information about s.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the number specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.FormatException:
			//     s is not of the correct format.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Int64.MinValue or greater than System.Int64.MaxValue.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: static int Parse(string* s, IFormatProvider* provider);
			//
			// Summary:
			//     Converts the string representation of a number in a specified style to its
			//     32-bit signed integer equivalent.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert.
			//
			//   style:
			//     A bitwise combination of the enumeration values that indicates the style
			//     elements that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the number specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is not
			//     a combination of System.Globalization.NumberStyles.AllowHexSpecifier and
			//     System.Globalization.NumberStyles.HexNumber values.
			//
			//   System.FormatException:
			//     s is not in a format compliant with style.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Int64.MinValue or greater than System.Int64.MaxValue.
			//     -or-s includes non-zero, fractional digits.
			public: static int Parse(string* s, Globalization::NumberStyles style);
			//
			// Summary:
			//     Converts the string representation of a number in a specified style and culture-specific
			//     format to its 32-bit signed integer equivalent.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer.
			//
			//   provider:
			//     An object that supplies culture-specific information about the format of
			//     s.
			//
			// Returns:
			//     A 32-bit signed integer equivalent to the number specified in s.
			//
			// Exceptions:
			//   System.ArgumentNullException:
			//     s is null.
			//
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is not
			//     a combination of System.Globalization.NumberStyles.AllowHexSpecifier and
			//     System.Globalization.NumberStyles.HexNumber values.
			//
			//   System.FormatException:
			//     s is not in a format compliant with style.
			//
			//   System.OverflowException:
			//     s represents a number less than System.Int64.MinValue or greater than System.Int64.MaxValue.
			//     -or-s includes non-zero, fractional digits.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: static int Parse(string* s, Globalization::NumberStyles style, IFormatProvider* provider);
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation.
			//
			// Returns:
			//     The string representation of the value of this instance, consisting of a
			//     negative sign if the value is negative, and a sequence of digits ranging
			//     from 0 to 9 with no leading zeroes.
			//[SecuritySafeCritical]
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: override GC_PTR<Riccsson::System::string> ToString();
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation
			//     using the specified culture-specific format information.
			//
			// Parameters:
			//   provider:
			//     An object that supplies culture-specific formatting information.
			//
			// Returns:
			//     The string representation of the value of this instance as specified by provider.
			//[SecuritySafeCritical]
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: GC_PTR<Riccsson::System::string> ToString(IFormatProvider* provider);
			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation,
			//     using the specified format.
			//
			// Parameters:
			//   format:
			//     A standard or custom numeric format string.
			//
			// Returns:
			//     The string representation of the value of this instance as specified by format.
			//
			// Exceptions:
			//   System.FormatException:
			//     format is invalid or not supported.
			//[SecuritySafeCritical]
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: GC_PTR<Riccsson::System::string> ToString(string* format);

			public: GC_PTR<Riccsson::System::string> ToString(const char* format);

			//
			// Summary:
			//     Converts the numeric value of this instance to its equivalent string representation
			//     using the specified format and culture-specific format information.
			//
			// Parameters:
			//   format:
			//     A standard or custom numeric format string.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information.
			//
			// Returns:
			//     The string representation of the value of this instance as specified by format
			//     and provider.
			//
			// Exceptions:
			//   System.FormatException:
			//     format is invalid or not supported.
			//[SecuritySafeCritical]
			public: GC_PTR<Riccsson::System::string> ToString(string* format, IFormatProvider* provider);
			//
			// Summary:
			//     Converts the string representation of a number to its 32-bit signed integer
			//     equivalent. A return value indicates whether the conversion succeeded.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert.
			//
			//   result:
			//     When this method returns, contains the 32-bit signed integer value equivalent
			//     to the number contained in s, if the conversion succeeded, or zero if the
			//     conversion failed. The conversion fails if the s parameter is null, is not
			//     of the correct format, or represents a number less than System.Int64.MinValue
			//     or greater than System.Int64.MaxValue. This parameter is passed uninitialized.
			//
			// Returns:
			//     true if s was converted successfully; otherwise, false.
			public: static bool TryParse(string* s, int out result);
			//
			// Summary:
			//     Converts the string representation of a number in a specified style and culture-specific
			//     format to its 32-bit signed integer equivalent. A return value indicates
			//     whether the conversion succeeded.
			//
			// Parameters:
			//   s:
			//     A string containing a number to convert. The string is interpreted using
			//     the style specified by style.
			//
			//   style:
			//     A bitwise combination of enumeration values that indicates the style elements
			//     that can be present in s. A typical value to specify is System.Globalization.NumberStyles.Integer.
			//
			//   provider:
			//     An object that supplies culture-specific formatting information about s.
			//
			//   result:
			//     When this method returns, contains the 32-bit signed integer value equivalent
			//     to the number contained in s, if the conversion succeeded, or zero if the
			//     conversion failed. The conversion fails if the s parameter is null, is not
			//     in a format compliant with style, or represents a number less than System.Int64.MinValue
			//     or greater than System.Int64.MaxValue. This parameter is passed uninitialized.
			//
			// Returns:
			//     true if s was converted successfully; otherwise, false.
			//
			// Exceptions:
			//   System.ArgumentException:
			//     style is not a System.Globalization.NumberStyles value. -or-style is not
			//     a combination of System.Globalization.NumberStyles.AllowHexSpecifier and
			//     System.Globalization.NumberStyles.HexNumber values.
			//[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
			public: static bool TryParse(string* s, Globalization::NumberStyles style, IFormatProvider* provider, int out result);

			private: bool ToBoolean(IFormatProvider* provider)
			{
				throw;
			}
			private: byte ToByte(IFormatProvider* provider)
			{
				throw;
			}
			private: char ToChar(IFormatProvider* provider)
			{
				throw;
			}
			private: DateTime ToDateTime(IFormatProvider* provider)
			{
				throw;
			}
			private: decimal ToDecimal(IFormatProvider* provider)
			{
				throw;
			}
			private: double ToDouble(IFormatProvider* provider)
			{
				throw;
			}
			private: short ToInt16(IFormatProvider* provider)
			{
				throw;
			}
			private: int ToInt32(IFormatProvider* provider)
			{
				throw;
			}
			private: long long ToInt64(IFormatProvider* provider)
			{
				throw;
			}
			private: sbyte ToSByte(IFormatProvider* provider)
			{
				throw;
			}
			private: float ToSingle(IFormatProvider* provider)
			{
				throw;
			}
			private: GC_PTR<object> ToType(Type* conversionType, IFormatProvider* provider)
			{
				throw;
			}
			private: ushort ToUInt16(IFormatProvider* provider)
			{
				throw;
			}
			private: uint ToUInt32(IFormatProvider* provider)
			{
				throw;
			}
			private: ulong ToUInt64(IFormatProvider* provider)
			{
				throw;
			}

			//----------------------------------------------------------------------------
			// +
			public: Int64 operator+ ( const Int64 value );

			//----------------------------------------------------------------------------
			// -
			public: Int64 operator- ( const Int64 value );

			//----------------------------------------------------------------------------
			// *
			public: Int64 operator* ( const Int64 value );

			//----------------------------------------------------------------------------
			// /
			public: Int64 operator/ ( const Int64 value );
			public: Int64 operator/ ( const int& value );

			//----------------------------------------------------------------------------
			// %
			public: Int64 operator% ( const Int64 value );

			//----------------------------------------------------------------------------
			// ++
			public: long long operator++ ();
		};

		
	}
}

#endif // Int64_H